#include <iostream>
using namespace std;

#include <vector>
#include <algorithm>

// int main()
//{
//	// i是常量表达式
//	//volatile const int i = 0;
//	const int i = 0;  // 常量表达式
//	cout << i << endl;
//	//int* ptr = (int*)&i;
//	int* ptr = const_cast<int*>(&i);
//	*ptr += 1;
//	cout << i << endl;
//
//	int j = 0;
//	const int k = j;  // 不是常量表达式
//	cout << k << endl;
//	ptr = const_cast<int*>(&k);
//	*ptr += 1;
//	cout << k << endl;
//
//	return 0;
// }

// int size()
// {
// 	int n = 10;
// 	return n;
// }

// int main()
// {
// 	const int a = 1; // a是常量表达式
// 	const int b = a + 1; // b是常量表达式
// 	int c = 1; // c不是常量表达式
// 	const int d = c; // d不是常量表达式
// 	const int e = size(); // e不是常量表达式

// 	// (VS环境下)这里数组大小必须是编译时确认的，可以用来判定是不是常量表达式
// 	int arr[b];

// 	constexpr int aa = 1;
// 	constexpr int bb = aa + 1;
// 	//constexpr int cc = c; // 报错
// 	//constexpr int cc = size(); // 报错
// 	cout << aa << endl;
// 	int* ptr = (int*)&aa;
// 	(*ptr)++;
// 	cout << aa << endl;

// 	//const int* p2 = &d;
// 	//constexpr const int* p3 = &d;
// 	//const int* const p3

// 	return 0;
// }

// constexpr int size()
//{
//	return 10;
// }
//
// constexpr int func(int x)
//{
//	return 10 + x;
// }
//
// constexpr int factorial(int n)
//{
//	return n <= 1 ? 1 : n * factorial(n - 1);
// }

// int main()
//{
//	constexpr int x = size();
//	constexpr int y = func(1);
//	constexpr int z = factorial(5);
//
//	cout << x << endl;
//	cout << y << endl;
//	cout << z << endl;
//
//	return 0;
// }

// constexpr int fxx(int x)
//{
//	int i = x;
//	i++;
//	cout << i << endl;
//	return 10 + x;
// }
//
// int main()
//{
//	// 编译时，N会被直接替换为10，constexpr函数默认就是inline
//	constexpr int N1 = size();
//	int arr1[N1];
//
//	// func传10时，func函数返回值是常量表达式，所以N2是常量表达式
//	constexpr int N2 = func(10);
//	int arr2[N2];
//
//	// func传10时，func函数返回值是常量表达式，所以N2是常量表达式
//	int i = 10;
//	//constexpr int N3 = func(i); // 报错func返回的不是常量表达式
//
//	int N4 = func(i); // 不报错constexpr函数返回的不一是常量表达式
//	int N5 = func(10);
//
//	constexpr int N6 = fxx(10); // 报错
//
//	return 0;
// }

// C++14允许的constexpr函数示例
// constexpr int factorial(int n) {
//	int res = 1; // 允许局部变量
//	for (int i = 2; i <= n; ++i) { // 允许循环
//		res *= i;
//	}
//	return res; // 单一 return
//}
//
// constexpr size_t stringLength(const char* str) {
//	size_t len = 0;
//	while (str[len] != '\0')
//		++len;
//	return len;
//}
//
// int main()
//{
//	constexpr size_t len = stringLength("Hello"); // 编译期计算：5
//	constexpr size_t n = factorial(5); // 编译期计算：5
//
//	cout << len << endl;
//	cout << n << endl;
//
//	return 0;
//}

// struct Point {
//	constexpr Point(double x, double y) : _x(x), _y(y)
//	{
//		_x++;
//		//cout << "constexpr Point(double x, double y)" << endl;
//	}
//
//	double _x, _y;
// };
//
// constexpr Point midpoint(Point a, Point b) {
//	return Point((a._x + b._x) / 2, (a._y + b._y) / 2);
// }
//
// constexpr std::array<int, 5> createArray() {
//	std::array<int, 5> arr = {1,2,3,4,5};
//	for (size_t i = 0; i < arr.size(); ++i) {
//		arr[i] = i * i;
//	}
//	return arr;
// }
//
// int main()
//{
//	Point p1 = midpoint({ 1.1,1.1 }, { 2.2,2.2 });
//	constexpr Point p2 = midpoint({ 1.1,1.1 }, { 2.2,2.2 });
//
//	constexpr std::array<int, 5> a1 = createArray();
//
//	return 0;
// }

//int main()
//{
//	// constexpr lambda示例
//	constexpr int n = 10;
//	int y = 0;
//	constexpr auto square = [n](int x) constexpr { return x * x * n; };
//	constexpr int result = square(5); // 编译期计算：250
//
//	return 0;
//}

// constexpr int dynamic_memory_example() {
// 	int* p = new int{ 42 }; // 编译期分配
// 	int value = *p;
// 	delete p; // 必须显式释放

// 	return value;
// }
// int main()
// {
// 	constexpr int v = dynamic_memory_example(); // 42
// 	return 0;
// }

//int main()
//{
//	// constexpr lambda示例
//	constexpr int n = 10;
//	int y = 0;
//	constexpr auto square = [n](int x) constexpr { return x * x * n; };
//	constexpr int result = square(5); // 编译期计算：250
//
//	return 0;
//}

//constexpr int dynamic_memory_example() {
//	int* p = new int{ 42 }; // 编译期分配
//	int value = *p;
//	delete p; // 必须显式释放
//
//	return value;
//}
//int main()
//{
//	constexpr int v = dynamic_memory_example(); // 42
//	return 0;
//}

//constexpr std::vector<int> build_lookup() {
//    std::vector<int> v;
//    for (int i = 0; i < 10; ++i) {
//        v.push_back(i * i);  // 编译期操作
//    }
//
//    return v;
//}
//
//int main()
//{
//    //constexpr auto lookup = build_lookup();  // 编译期生成
//    constexpr vector<int> v(10, 1);
//
//    return 0;
//}
//
//constexpr auto sort_example() {
//	std::array<int, 5> arr{ 5, 3, 4, 1, 2 };
//	std::sort(arr.begin(), arr.end()); // 编译期排序
//	return arr;
//}
//
//int main()
//{
//	constexpr array<int, 10> a1 = { 3,2,1,4,5 };
//	vector<int> v2 = { 3,2,1,4,5 };
//	sort(v2.begin(), v2.end());
//	//sort(a1.begin(), a1.end());
//	auto it1 = find(v2.begin(), v2.end(), 3);
//
//	// 相对有限支持的constexpr
//	constexpr auto sorted = sort_example(); // {1,2,3,4,5}
//
//	constexpr auto it2 = find(a1.begin(), a1.end(), 4);
//	//static_assert(*it2 == 4, "编译期查找");
//
//
//	return 0;
//}

//#include<iostream>
//using namespace std;
//constexpr int safe_divide(int a, int b) {
//	try {
//		if (b == 0)
//			throw "Division by zero";
//		else
//			return a / b;
//	}
//	catch (...) {
//		return 0; // 编译期异常处理
//	}
//}
//int main()
//{
//	constexpr int val1 = safe_divide(10, 2); // 5
//	constexpr int val2 = safe_divide(10, 0); // 报错
//}

// class A {
// 	mutable int _i;
// 	int _j;
// public:
// 	constexpr A(int i, int j)
// 		:_i(i)
// 		, _j(j)
// 	{}

// 	constexpr int Func() const
// 	{
// 		++_i; // 可以修改
// 		//++_j; // 不能修改

// 		return _i + _j;
// 	}
// };

// class Base {
// public:
// 	virtual constexpr int value() const { return 1; }
// };

// class Derived : public Base {
// public:
// 	virtual constexpr int value() const override { return 2; }
// };

// constexpr int get_value(const Base& b) {
// 	return b.value(); // 编译期多态调用
// }

// int main()
// {
// 	constexpr A aa(1, 1);
// 	constexpr int ret = aa.Func();

// 	constexpr int ret1 = get_value(Base());
// 	constexpr int ret2 = get_value(Derived());

// 	return 0;
// }